﻿using Himp.Base;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.ObjectMapping;

namespace Himp.Platform
{
    /// <summary>
    /// 分类字典
    /// </summary>
    public class CatgeDictService : PlatformAppService
    {
        private readonly IRepository<CatgeDict, Guid> _catgeDictRepository;
        private readonly IBizSeqService _bizSeqService;
        private CatgeDictManager _catgeDictManager;

        public CatgeDictService(IRepository<CatgeDict, Guid> catgeDictRepository
            , CatgeDictManager catgeDictManager
            , IBizSeqService bizSeqService)
        {
            _catgeDictRepository = catgeDictRepository;
            _catgeDictManager = catgeDictManager;
            _bizSeqService = bizSeqService;
        }

        /// <summary>
        /// 获字分类字典列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<PagedResultDto<CatgeDictDto>> GetListAsync(CatgeDictInput input)
        {
            var res = await _catgeDictManager.GetList(input.Pi, input.Ps,input.TypeCode, input.Filter);
            var itemsDto = ObjectMapper.Map<List<CatgeDict>, List<CatgeDictDto>>(res.Item1);

            return new PagedResultDto<CatgeDictDto>(res.Item2, itemsDto);
        }

        /// <summary>
        /// 获字分类字典明细
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<CatgeDictDto> GetAsync(Guid id)
        { 
            var catgeDict = await _catgeDictRepository.GetAsync(id);

            return ObjectMapper.Map<CatgeDict, CatgeDictDto>(catgeDict);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task DeleteAsync(Guid id)
        {
            if (await _catgeDictManager.DeleteRuleCheck(id)) 
            {
                await _catgeDictRepository.DeleteAsync(id);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<CatgeDictDto> PostAsync(CatgeDictCreateDto input)
        {
            var catgeDict = ObjectMapper.Map<CatgeDictCreateDto, CatgeDict>(input);

            if (input.ParentId == null)
            {
                catgeDict.CatgeCodg = catgeDict.TypeCode;
            }
            else if(!string.IsNullOrEmpty( input.CatgeCodg))
            {
                catgeDict.CatgeCodg = input.CatgeCodg;
            }
            else
            {
                var catgeCodg = await _bizSeqService.GetAsync(catgeDict.TypeCode, "{0:00}");
                catgeDict.CatgeCodg = catgeDict.TypeCode + catgeCodg;
            }
            
            catgeDict = await _catgeDictRepository.InsertAsync(catgeDict);
            var itemDto = ObjectMapper.Map<CatgeDict, CatgeDictDto>(catgeDict);

            return itemDto;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<CatgeDictDto> PutAsync(Guid id, CatgeDictUpdateDto input)
        {
            var catgeDict = await _catgeDictRepository.GetAsync(id);
            catgeDict = ObjectMapper.Map<CatgeDictUpdateDto, CatgeDict>(input, catgeDict);
            catgeDict = await _catgeDictRepository.UpdateAsync(catgeDict);
            var itemDto = ObjectMapper.Map<CatgeDict, CatgeDictDto>(catgeDict);

            return itemDto;
        }
    }
}
